home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 1 / PC World Interactive 1 - Nisan 1997.iso / nostalji / bbs / music / sbbook.arj / SBBOOK / SOURCE / TP / DRVRFUNC.PAS next >
Encoding:
Pascal/Delphi Source File  |  1993-11-29  |  24.4 KB  |  837 lines
  1. (*
  2.     ---------------------
  3.      SBSIM ERROR MESSAGES
  4.     ---------------------
  5.  *)
  6.  
  7. type simerr = (SIMerr_NoErr,         (* No error occured                  *)
  8.            SIMerr_IsBusy,        (* SBSIM currently in use            *)
  9.            SIMerr_BadDriver,     (* Bad driver specified              *)
  10.            SIMerr_BadFunction,   (* Bad function specified            *)
  11.            SIMerr_VoiceActive,   (* A voice process is already active *)
  12.            SIMerr_VMEMnoStart,   (* Couldn't start CT-VOICE           *)
  13.            SIMerr_VDSKnoStart,   (* Couldn't start CTVDSK             *)
  14.            SIMerr_BadSIMhandle,  (* Invalid SBSIM handle              *)
  15.            SIMerr_BadBuffer,     (* Buffer not initialized yet        *)
  16.            SIMerr_BadFile,          (* Bad file name given               *)
  17.            SIMerr_BadFileHandle, (* Bad file handle                   *)
  18.            SIMerr_NotInited,     (* Driver not started yet            *)
  19.            SIMerr_NoXMS,          (* XMS driver not installed          *)
  20.            SIMerr_NoSIMfree,     (* No free SBSIM handles             *)
  21.            SIMerr_BadFileType,   (* Bad file type specified           *)
  22.            SIMerr_BadFreeXMS,    (* Couldn't free XMS block           *)
  23.            SIMerr_AuxBadSource,  (* Invalid source selected           *)
  24.            SIMerr_BadPanGet,     (* Get pan position failed           *)
  25.            SIMerr_BadPanSet,     (* Set pan position failed           *)
  26.            SIMerr_BadVolSet,     (* Set volume failed                 *)
  27.            SIMerr_FPbadStart,    (* Couldn't start fade/pan           *)
  28.            SIMerr_FPbadStop,     (* Couldn't stop fade/pan            *)
  29.            SIMerr_FPbadPause,    (* Couldn't pause fade/pan           *)
  30.            SIMerr_FPbadType,     (* Not a fade/pan operation          *)
  31.            SIMerr_FPbadMode,     (* Bad mode for fade/pan             *)
  32.            SIMerr_FPfailed,         (* Couldn't start fade/pan           *)
  33.            SIMerr_FPnotFadePan,  (* Source not fading/panning         *)
  34.            SIMerr_MusicActive,   (* FM or MIDI already playing        *)
  35.            SIMerr_BadMapper         (* Bad MIDI mapper format            *)
  36.            );
  37.  
  38.  
  39. (*
  40.     --------------
  41.      ENUMERATIONS
  42.     --------------
  43.  *)
  44.  
  45. type drivertype = (FM, DskVoice, MemVoice, AuxDrv, Midi);
  46.  
  47. type sourcetype = (MASTER, VOICE, SYNTH, CD, LINE, MIC);
  48.  
  49.  (* for DOS file functions *)
  50. type AccessType = (ReadAccess, WriteAccess, RdWrAccess);
  51.  
  52.  
  53. (*
  54.     ------------------------
  55.      STRUCTURE DEFINITIONS
  56.     ------------------------
  57.  *)
  58.  
  59. type driverinfo = record        (* driver information structure *)
  60.      loaded: boolean;
  61.      entry,
  62.      bufLoc: pointer;
  63.      bufSize: word;
  64.      end;
  65.  
  66.  
  67. (*
  68.     ------------------
  69.      GLOBAL VARIABLES
  70.     ------------------
  71.  *)
  72.  
  73. var SIMint:integer;  (* Interrupt used to access SBSIM *)
  74.  
  75.  
  76.  
  77. (*--- SBSIM error messages ------------------*)
  78.  
  79. const errorMsg:array[SIMerr_NoErr .. SIMerr_BadMapper] of string[40] =
  80.                    ('',
  81.             'SBSIM currently in use',
  82.             'Bad driver specified',
  83.             'Bad function specified',
  84.             'Voice process is already active',
  85.             'Couldn''t start CT-VOICE',
  86.             'Couldn''t start CTVDSK',
  87.             'Invalid SBSIM handle',
  88.             'Buffer not initialized yet',
  89.             'Bad file name for load',
  90.             'Bad file handle',
  91.             'Driver not started yet',
  92.             'XMS driver not installed',
  93.             'No free SBSIM handles',
  94.             'Bad file type specified',
  95.             'Couldn''t free XMS block',
  96.             'Invalid source selected',
  97.             'Get-Pan-Position failed',
  98.             'Set-Pan-Position failed',
  99.             'Set-Volume failed',
  100.             'Couldn''t start fade/pan',
  101.             'Couldn''t stop fade/pan',
  102.             'Couldn''t pause fade/pan',
  103.             'Not a fade/pan operation',
  104.             'Bad mode for fade/pan',
  105.             'Couldn''t start fade/pan',
  106.             'Source not fading/panning',
  107.             'FM or MIDI already playing',
  108.             'Bad MIDI mapper format');
  109.  
  110.  
  111. (************ I added these functions ******************)
  112.  
  113. (*************************************************************************
  114. *
  115. * FUNCTION: AsciiZ - Given a Turbo Pascal string, this function returns a
  116. *                    pointer to a C type of string.  The original string
  117. *                    should have enough storage space to append a chr(0) to
  118. *                    the end.
  119. * Inputs: str - a Turbo Pascal type of string.
  120. *
  121. * Output: a pointer to a null-terminated character array.
  122. *
  123. *************************************************************************)
  124. function AsciiZ(var str:string):pointer;
  125.  
  126. begin
  127. if str[length(str)] <> chr(0)
  128. then str := str + chr(0);  (* add null terminator *)
  129.  
  130. (* first byte of string is length byte, so move pointer past it *)
  131. AsciiZ := ptr(seg(str), ofs(str)+1);  (* return pointer to first character *)
  132. end;
  133.  
  134.  
  135.  
  136. (*************************************************************************
  137. *
  138. * FUNCTION: DosOpen - Calls DOS to open a file.
  139. *
  140. * Inputs: fname - a Turbo Pascal type of string
  141. *         mode  - a var of type AccessType; specifies whether the file is
  142. *                 to be opened for reading, writing, or both.
  143. * Output:
  144. *   if successful    :  a file handle
  145. *   if not successful:  -1
  146. *
  147. *************************************************************************)
  148. function DosOpen(fname:string; mode:AccessType):integer;
  149.  
  150. var regs:registers;
  151.     ptr:pointer;
  152.  
  153. begin
  154. ptr := AsciiZ(fname);   (* need null-terminated string *)  
  155.  
  156. regs.ah := $3D;         (* DOS function number *)
  157. regs.al := word(mode);
  158.  
  159. regs.dx := ofs(ptr^);   (* pointer to file name *)
  160. regs.ds := seg(ptr^);
  161.  
  162. msdos(regs);            (* call MS-DOS *)
  163.  
  164. if (regs.flags and FCarry) <> 0
  165. then DosOpen := -1
  166. else DosOpen := regs.ax;
  167. end;
  168.  
  169.  
  170. (*************************************************************************
  171. *
  172. * FUNCTION: DosClose - Calls DOS to close a file.
  173. *
  174. * Inputs: fhandle - the handle of a file previously opened with DosOpen.
  175. *
  176. * Output: none
  177. *
  178. * Note  : DOS does return an error number, which can be returned by this
  179. *         function by removing the comment delimiters from the last line.
  180. *
  181. *************************************************************************)
  182. procedure DosClose(fhandle:integer);
  183.  
  184. var regs:registers;
  185.  
  186. begin
  187. regs.ah := $3E;                 (* DOS function number *)
  188. regs.bx := word(fhandle);
  189. msdos(regs);
  190. (* DosClose := regs.ax; put this in if you want a function *)
  191. end;
  192.  
  193.  
  194.  
  195.  
  196. (*************************************************************************
  197. *
  198. * FUNCTION: FINDDVR - Searches for the requested driver's interrupt number
  199. *                     by looking for IDStr (in this case it will be
  200. *                     SBSIM) in the interrupt vector table memory at the
  201. *                     offset (as in SEGMENT:OFFSET) location passed to
  202. *                     this function.
  203. *
  204. * Inputs: IDStr - driver ID string (i.e. "SBSIM").
  205. *         IDOff - driver's ID offset.
  206. *
  207. * Output: interrupt number or 0 (error condition) if not found.
  208. *
  209. *************************************************************************)
  210. function FindDvr(IDStr:string; IDOff:word):word;
  211.  
  212. var dvrInt:word;
  213.     intFound:boolean;
  214.     dvrVec:pointer;
  215.     i:integer;
  216.  
  217. begin
  218. dvrInt := $80;
  219. repeat
  220.      getintvec(dvrInt, dvrVec);
  221.      intFound:=true;
  222.      i:=1;
  223.      while (i<=length(IDStr)) and intFound do
  224.           begin
  225.           if char(mem[seg(dvrVec^):IDOff+i-1]) <> IDStr[i]
  226.           then intFound:=false;
  227.           inc(i);
  228.           end;
  229.      inc(dvrInt);
  230. until (dvrInt > $C0) or (intFound = true);
  231.  
  232. if intFound = true
  233. then FindDvr := dvrInt-1
  234. else FindDvr := 0;
  235.  
  236. end;
  237.  
  238.  
  239.  
  240. (*************************************************************************
  241. *
  242. * FUNCTION: VERSION - Get the current version of SBSIM.
  243. *
  244. * Inputs: none
  245. *
  246. * Output: version = high byte, sub-version = low byte.
  247. *
  248. * note: requires SIMint be defined before calling.
  249. *
  250. *************************************************************************)
  251. function Version:word;
  252.  
  253. var regs:registers;
  254.  
  255. begin
  256. regs.bh := 0;           (* control function *)
  257. regs.bl := 0;           (* query version sub-fn *)
  258. intr(SIMint, regs);
  259. Version := regs.ax;     (* return version number *)
  260. end;
  261.  
  262.  
  263.  
  264. (*************************************************************************
  265. *
  266. * FUNCTION: GETDRVRS - Determines which drivers are loaded.
  267. *
  268. * Inputs: none
  269. *
  270. * Output: bit field indicating which drivers are loaded.
  271. *
  272. *         bit 0 - FM driver
  273. *         bit 1 - Double disk buffered voice driver
  274. *         bit 2 - Memory voice driver
  275. *         bit 3 - Auxiliary driver (mixer)
  276. *         bit 4 - MIDI driver
  277. *
  278. * note: requires SIMint be defined before calling.
  279. *
  280. *************************************************************************)
  281. function GetDrvrs:word;
  282.  
  283. var regs:registers;
  284.  
  285. begin
  286. regs.bh := 0;           (* control function     *)
  287. regs.bl := 1;           (* query drivers sub-fn *)
  288. intr(SIMint, regs);
  289. GetDrvrs := regs.ax;    (* return driver bit field *)
  290. end;
  291.  
  292.  
  293.  
  294. (*************************************************************************
  295. *
  296. * FUNCTION: GETADDRESS - Returns selected driver's entry address.
  297. *
  298. * Inputs: driver   0 - FM driver
  299. *                  1 - Double disk buffered voice driver
  300. *                  2 - Memory voice driver
  301. *                  3 - Auxiliary driver (mixer)
  302. *                  4 - MIDI driver
  303. *         address - storage for entry address pointer
  304. *
  305. * Output: 0 if no error.
  306. *
  307. * note: requires SIMint be defined before calling.
  308. *
  309. *************************************************************************)
  310. function GetAddress(driver:drivertype; var address:pointer):simerr;
  311.  
  312. var regs:registers;
  313.  
  314. begin
  315. regs.bh := 0;            (* control function *)
  316. regs.bl := 2;            (* driver entry address sub-fn *)
  317. regs.ax := word(driver);
  318. intr(SIMint, regs);
  319. address := ptr(regs.dx, regs.ax);  (* return address *)
  320.  
  321. if (regs.flags and FCarry)=0       (* test for errors *)
  322. then GetAddress:=simerr(0)         (* return result *)
  323. else GetAddress:=simerr(regs.ax);  (* error occured *)
  324. end;
  325.  
  326.  
  327. (*************************************************************************
  328. *
  329. * FUNCTION: GETBUFINFO - Returns selected driver's buffer address.
  330. *
  331. * Inputs: driver   0 - FM driver
  332. *                  1 - Double disk buffered voice driver
  333. *                  4 - MIDI driver
  334. *         address - variable in which address of buffer will be stored.
  335. *         size    - variable in which size of buffer (in Kbytes) will be
  336. *                   stored.
  337. *
  338. * Output: 0 if no error
  339. *
  340. * note: requires SIMint be defined before calling.
  341. *
  342. *************************************************************************)
  343. function GetBufInfo(driver:drivertype; var address:pointer; var size:word):simerr;
  344.  
  345. var regs:registers;
  346.  
  347. begin
  348. regs.bh := 0;       (* control function *)
  349. regs.bl := 5;       (* driver entry address sub-fn *)
  350. regs.ax := word(driver);
  351. intr(SIMint, regs);
  352. address := ptr(regs.dx, regs.ax);  (* return address *)
  353. size := regs.cx;                   (* return buffer size *)
  354.  
  355. if (regs.flags and FCarry)=0       (* test for errors *)
  356. then GetBufInfo:=simerr(0)         (* No error *)
  357. else GetBufInfo:=simerr(regs.ax);  (* error occured *)
  358. end;
  359.  
  360.  
  361. (*************************************************************************
  362. *
  363. * FUNCTION: STARTSND - Initializes the driver for output.
  364. *
  365. * Inputs: driver:  0 - FM driver
  366. *                  1 - Double disk buffered voice driver
  367. *                  2 - Memory voice driver
  368. *                  4 - MIDI driver
  369. *
  370. *         ptr: pointer to filename or memory location.
  371. *
  372. *         ExtMemVoc:
  373. *             true  - if the file is a .VOC file to be
  374. *                     played from extended memory.
  375. *             false - Anything except a .VOC file from extended memory
  376. *
  377. * Output: Initialization result
  378. *
  379. * note: requires SIMint be defined before calling.
  380. *
  381. *************************************************************************)
  382. function StartSnd(driver:drivertype; ptr:pointer; ExtMemVoc:boolean;
  383.  SBSIMHandle:integer):simerr;
  384.  
  385. var regs:registers;
  386.  
  387. begin
  388. regs.bh := word(driver) + 1;
  389. regs.bl := 0;                 (* start sound source function *)
  390. regs.cx := 0;
  391.  
  392. if (ExtMemVoc)           
  393. then begin                    (* extended memory voc file *)
  394.      regs.ax := SBSIMHandle;
  395.      regs.dx := 0;
  396.      end
  397. else if driver=MemVoice
  398. then begin                    (*  conventional memory .voc file *)
  399.      regs.ax := ofs(ptr^);    (* pointer to data buffer *)
  400.      regs.dx := seg(ptr^);
  401.      end
  402. else begin                    (* FM, MIDI, or DskVoice *)
  403.      regs.ax := ofs(ptr^);    (* pointer to filename *)
  404.      regs.ds := seg(ptr^);
  405.      end;
  406.  
  407. intr(SIMint, regs);
  408.  
  409. StartSnd := simerr(regs.ax);  (* return initialization result *)
  410. end;
  411.  
  412.  
  413. (*************************************************************************
  414. *
  415. * FUNCTION: GETSNDSTAT - Get the driver's status.
  416. *
  417. * Inputs: driver   0 - FM driver
  418. *                  1 - Double disk buffered voice driver
  419. *                  2 - Memory voice driver
  420. *                  4 - MIDI driver
  421. *
  422. * Output: Current status
  423. *
  424. * note: requires SIMint be defined before calling.
  425. *
  426. * RETURNS: -1 (negative one) if still playing
  427. *           0 (zero) if done playing
  428. *
  429. *************************************************************************)
  430. function GetSndStat(driver:drivertype):word;
  431.  
  432. var regs:registers;
  433.  
  434. begin
  435. regs.bh := word(driver) + 1;
  436. regs.bl := 5;                 (* get sound status function *)
  437. regs.cx := 0;
  438. intr(SIMint, regs);
  439. GetSndStat := regs.ax;        (* return status *)
  440. end;
  441.  
  442.  
  443. (*************************************************************************
  444. *
  445. * FUNCTION: PLAYSND - Plays music/voice on the selected driver.
  446. *
  447. * Inputs: driver   0 - FM driver
  448. *                  1 - Double disk buffered voice driver
  449. *                  2 - Memory voice driver
  450. *                  4 - MIDI driver
  451. *
  452. * Output: Result
  453. *
  454. * note: requires SIMint be defined before calling.
  455. *
  456. *************************************************************************)
  457. function PlaySnd(driver:drivertype):simerr;
  458.  
  459. var regs:registers;
  460.  
  461. begin
  462. regs.bh := word(driver) + 1;
  463. regs.bl := 1;                 (* play sound function *)
  464. regs.cx := 0;
  465. intr(SIMint, regs);
  466. PlaySnd := simerr(regs.ax);   (* return result *)
  467. end;
  468.  
  469.  
  470. (*************************************************************************
  471. *
  472. * FUNCTION: STOPSND - Stops music/voice on the selected driver.
  473. *
  474. * Inputs: driver   0 - FM driver
  475. *                  1 - Double disk buffered voice driver
  476. *                  2 - Memory voice driver
  477. *                  4 - MIDI driver
  478. *
  479. * Output: none
  480. *
  481. * note: requires SIMint be defined before calling.
  482. *
  483. *************************************************************************)
  484. procedure StopSnd(driver:drivertype);
  485.  
  486. var regs:registers;
  487.  
  488. begin
  489. regs.bh := word(driver) + 1;
  490. regs.bl := 2;                 (* stop sound function *)
  491. regs.cx := 0;
  492. intr(SIMint, regs);
  493. end;
  494.  
  495.  
  496. (*************************************************************************
  497. *
  498. * FUNCTION: PAUSESND - Pauses music/voice on the selected driver.
  499. *
  500. * Inputs: driver   0 - FM driver
  501. *                  1 - Double disk buffered voice driver
  502. *                  2 - Memory voice driver
  503. *                  4 - MIDI driver
  504. *
  505. * Output: None
  506. *
  507. * note: requires SIMint be defined before calling.
  508. *
  509. *************************************************************************)
  510. procedure PauseSnd(driver:drivertype);
  511.  
  512. var regs:registers;
  513.  
  514. begin
  515. regs.bh := word(driver) + 1;
  516. regs.bl := 3;                 (* pause sound function *)
  517. regs.cx := 0;
  518. intr(SIMint, regs);
  519. end;
  520.  
  521.  
  522. (*************************************************************************
  523. *
  524. * FUNCTION: RESUMESND - Continues paused music/voice.
  525. *
  526. * Inputs: driver   0 - FM driver
  527. *                  1 - Double disk buffered voice driver
  528. *                  2 - Memory voice driver
  529. *                  4 - MIDI driver
  530. *
  531. * Output: none
  532. *
  533. * note: requires SIMint be defined before calling.
  534. *
  535. *************************************************************************)
  536. procedure ResumeSnd(driver:drivertype);
  537.  
  538. var regs:registers;
  539.  
  540. begin
  541. regs.bh := word(driver) + 1;
  542. regs.bl := 4;                 (* resume sound function *)
  543. regs.cx := 0;
  544. intr(SIMint, regs);
  545. end;
  546.  
  547.  
  548. (*************************************************************************
  549. *
  550. * FUNCTION: GETVOLUME - Get the source's volume.
  551. *
  552. * Inputs: source  0 - Master volume
  553. *                 1 - Voice volume
  554. *                 2 - MIDI volume
  555. *                 3 - CD volume
  556. *                 4 - Line-in volume
  557. *                 5 - Microphone volume
  558. *         volume - source's volume returned in this variable
  559. *
  560. * Output: 0 if no error
  561. *
  562. * note: requires SIMint be defined before calling.
  563. *
  564. *************************************************************************)
  565. function GetVolume(source:sourcetype; var volume:word):simerr;
  566.  
  567. var regs:registers;
  568.  
  569. begin
  570. regs.ax := word(source);
  571. regs.bh := 4;            (* auxilary function *)
  572. regs.bl := 0;            (* get source volume sub-function *)
  573. intr(SIMint, regs);
  574. volume := regs.ax;       (* return volume *)
  575.  
  576. if (regs.flags and FCarry)=0       (* test for errors *)
  577. then GetVolume:=simerr(0)          (* No error *)
  578. else GetVolume:=simerr(regs.ax);   (* error occured *)
  579. end;
  580.  
  581.  
  582. (*************************************************************************
  583. *
  584. * FUNCTION: SETVOLUME - Set the source's volume.
  585. *
  586. * Inputs: source  0 - Master volume
  587. *                 1 - Voice volume
  588. *                 2 - FM volume
  589. *                 3 - CD volume
  590. *                 4 - Line-in volume
  591. *                 5 - Microphone volume
  592. *         volume - source's new volume
  593. *
  594. * Output: 0 if no error
  595. *
  596. * note: requires SIMint be defined before calling.
  597. *
  598. *************************************************************************)
  599. function SetVolume(source:sourcetype; volume:word):simerr;
  600.  
  601. var regs:registers;
  602.  
  603. begin
  604. regs.bh := 4;            (* auxilary function *)
  605. regs.bl := 1;            (* set source volume sub-function *)
  606. regs.ax := word(source);
  607. regs.dx := volume;
  608. intr(SIMint, regs);
  609. SetVolume:=simerr(regs.ax);
  610. end;
  611.  
  612.  
  613. (*************************************************************************
  614. *
  615. * FUNCTION: GETGAIN - Get the SB16's gain.
  616. *
  617. * Inputs: direction  0 - input gain
  618. *                    1 - output gain
  619. *         level - the gain is returned in this variable
  620. *                 MSB = left
  621. *                 LSB = right
  622. *
  623. * Output: 0 if no error
  624. *
  625. * note: requires SIMint be defined before calling.
  626. *
  627. *************************************************************************)
  628. function GetGain(direction:integer; var level:word):simerr;
  629.  
  630. var regs:registers;
  631.  
  632. begin
  633. regs.ax := word(direction);    (* 0=input gain, 1=output gain *)
  634. regs.bh := 4;                  (* auxilary function *)
  635. regs.bl := 2;                  (* get gain sub-function *)
  636. intr(SIMint, regs);
  637. level:= regs.ax;               (* return volume *)
  638.  
  639. if (regs.flags and FCarry)=0       (* test for errors *)
  640. then GetGain:=simerr(0)            (* No error *)
  641. else GetGain:=simerr(regs.ax);     (* error occured *)
  642. end;
  643.  
  644.  
  645. (*************************************************************************
  646. *
  647. * FUNCTION: SETGAIN - Set the SB16's gain.
  648. *
  649. * Inputs: direction  0 - input gain
  650. *                    1 - output gain
  651. *         level  - new gain value
  652. *                  MSB = left
  653. *                  LSB = right
  654. *
  655. * Output: 0 if no error
  656. *
  657. * note: requires SIMint be defined before calling.
  658. *
  659. *************************************************************************)
  660. function SetGain(dir:integer; level:word):simerr;
  661.  
  662. var regs:registers;
  663.  
  664. begin
  665. regs.bh := 4;            (* auxilary function *)
  666. regs.bl := 3;            (* set gain sub-function *)
  667. regs.ax := word(direction);
  668. regs.dx := level;
  669. intr(SIMint, regs);
  670.  
  671. if (regs.flags and FCarry)=0       (* test for errors *)
  672. then SetGain:=simerr(0)            (* No error *)
  673. else SetGain:=simerr(regs.ax);     (* error occured *)
  674. end;
  675.  
  676.  
  677. (*************************************************************************
  678. *
  679. * FUNCTION: GETTONE- Get the SB16's tone.
  680. *
  681. * Inputs: band    0 - Treble
  682. *                 1 - Bass
  683. *         level - the treble or bass tone is returned in this variable
  684. *
  685. * Output: 0 if no error
  686. *
  687. * note: requires SIMint be defined before calling.
  688. *
  689. *************************************************************************)
  690. function GetTone(band:integer; var level:word):simerr;
  691.  
  692. var regs:registers;
  693.  
  694. begin
  695. regs.ax := word(band);
  696. regs.bh := 4;            (* auxilary function *)
  697. regs.bl := 4;            (* get tone sub-function *)
  698. intr(SIMint, regs);
  699. level:= regs.ax;          (* return volume *)
  700.  
  701. if (regs.flags and FCarry)=0       (* test for errors *)
  702. then GetTone:=simerr(0)            (* No error *)
  703. else GetTone:=simerr(regs.ax);     (* error occured *)
  704. end;
  705.  
  706.  
  707. (*************************************************************************
  708. *
  709. * FUNCTION: SETTONE - Set the SB16's tone.
  710. *
  711. * Inputs: band    0 - Treble
  712. *                 1 - Bass
  713. *         level - new treble or bass tone
  714. *
  715. * Output: 0 if no error
  716. *
  717. * note: requires SIMint be defined before calling.
  718. *
  719. *************************************************************************)
  720. function SetTone(band:integer; level:word):simerr;
  721.  
  722. var regs:registers;
  723.  
  724. begin
  725. regs.bh := 4;            (* auxilary function *)
  726. regs.bl := 5;            (* set tone sub-function *)
  727. regs.ax := word(band);
  728. regs.dx := level;
  729. intr(SIMint, regs);
  730.  
  731. if (regs.flags and FCarry)=0       (* test for errors *)
  732. then SetTone:=simerr(0)            (* No error *)
  733. else SetTone:=simerr(regs.ax);     (* error occured *)
  734. end;
  735.  
  736.  
  737. (*************************************************************************
  738. *
  739. *
  740. * FUNCTION: LoadExtMem() - Load a .VOC file into extended memory.
  741. *
  742. * Inputs:  Ptr - pointer to null-terminated string that string that contains
  743. *                the filename to be loaded into extended memory.
  744. *                (Example:  C:\VOICE\TEST.VOC)
  745. *          retval - SBSIM handle will be returned in this variable.
  746. * Output:
  747. *   if successful - returns true, and SBSIM handle is in retval
  748. *   if not        - returns false.
  749. *
  750. *************************************************************************)
  751. function LoadExtMem(Ptr:pointer; var retval:integer):boolean;
  752.  
  753. var regs:registers;
  754.  
  755. begin
  756. regs.dx := ofs(Ptr^);
  757. regs.ds := seg(Ptr^);
  758.  
  759. regs.bh := 0;
  760. regs.bl := 16;
  761. regs.ax := 0;
  762. regs.cx := 0;  (* Have driver assign you a handle (returned in AX) *)
  763. intr(SIMint, regs);
  764.  
  765. if (regs.flags and FCarry) <> 0  (* an error has occurred *)
  766. then LoadExtMem := false
  767. else LoadExtMem := true;
  768.  
  769. retval := integer(regs.ax);  (* return extended mem. handle, or error code *)
  770. end;
  771.  
  772.  
  773. (*************************************************************************
  774. *
  775. *
  776. * FUNCTION: FreeExtMem() - Releases the memory in extended memory.
  777. *
  778. * DESCRIPTION: Pass the SBSIMHandle obtained by LoadExtMem() to this
  779. *              function.  The extended memory used by the LoadExtMem()
  780. *              will then be freed.
  781. *
  782. * RETURNS: 0 - (zero) if there are NO errors.  Otherwise a SIMERR type
  783. *              will be returned.
  784. *
  785. *************************************************************************)
  786. function FreeExtMem(SBSIMHandle:integer):simerr;
  787.  
  788. var regs:registers;
  789.  
  790. begin
  791. regs.bh := 0;
  792. regs.bl := 19;
  793. regs.ax := SBSIMHandle;
  794. intr(SIMint, regs);
  795.  
  796. FreeExtMem := simerr(regs.ax);  (* return result *)
  797. end;
  798.  
  799.  
  800. (*************************************************************************
  801. *
  802. * FUNCTION: GETDVRINFO - Get status, entry point, buffer location, and
  803. *                        buffer size from SBSIM.  The DVRINFO struct gets
  804. *                        loaded with this information
  805. *
  806. * Inputs: driver - driver to get info on.
  807. *         *dvrInfo - pointer to DVRINFO structure.
  808. *
  809. * Output: status - the driver's status.
  810. *
  811. * note: requires SIMint be defined before calling.
  812. *
  813. *************************************************************************)
  814. function GetDvrInfo(driver:drivertype; var dvrInfo:driverinfo):boolean;
  815.  
  816. var dvrLoc:integer;
  817.     dummy:simerr;
  818.  
  819. begin
  820. dvrLoc := 1 shl word(driver);
  821. if (GetDrvrs and dvrLoc) = dvrLoc
  822. then begin
  823.      dvrInfo.loaded := true;
  824.      dummy := GetAddress(driver, dvrInfo.entry);  (* discard results *)
  825.      if (GetBufInfo(driver, dvrInfo.bufLoc, dvrInfo.bufSize) <> SIMerr_NoErr)
  826.      then begin
  827.           dvrInfo.bufLoc := nil;
  828.           dvrInfo.bufSize := 0;
  829.           end;
  830.      end
  831. else
  832.      dvrInfo.loaded := false;
  833.  
  834. GetDvrInfo := dvrInfo.loaded;
  835. end;
  836.  
  837.